﻿using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;

namespace Poke_Tactics
{
    class Object
    {
        protected GameWindow window;
        protected Texture2D imagem;
        protected Vector2 posicao;
        public Vector2 posicao_old;

        public Vector2 Posicao
        {
            get
            {
                return new Vector2(posicao.X + 16, posicao.Y + 16);
            }
            set
            {
                posicao_old = posicao;
                posicao = new Vector2(value.X - 16, value.Y - 16);
            }
        }
        protected Vector2 velocidade;
        protected Rectangle origem;
        protected Rectangle destino;
        protected float rotacao;
        protected Vector2 pivo;
        protected bool direita;

        public bool isWalking;
        public List<Vector2> walkWay;

        protected float escala;

        public bool visivel;

        public static List<Object> listaGameObjects = new List<Object>();
        public List<animacao> listaAnimacoes = new List<animacao>();

        protected float camada;
        
        private float alfa;
        /// <summary>
        /// Garantir que seja entre 0 e 1
        /// </summary>
        public float Alfa
        {
            get { return alfa; }
            set
            {
                if ((value >= 0) && (value <= 1))
                    alfa = value;
                else
                {
                    //jogar warning
                }
            }
        }
        protected Color cor;
        protected Rectangle colisao;
        public Rectangle Colisao
        {
            get
            {
                return colisao;
            }
            set
            {
                colisao = value;
            }
        }

        public struct animacao
        {

            //Imagem da animaçã (sheet)
            public Texture2D imagem;
            //Largura do frame
            public int width;
            //Altura do frame
            public int height;
            //Quantidade de frames da animação.
            public int qtd_quadros;
            //Quadro atual da animação.
            public int quadro_atual;
            //Quantidade de quadros por segundo
            public int quadros_seg;
            //Quadro Y, no caso, animações, "Andares" da spritesheet.
            public int animacao_Y;
            //Nome da animação
            public string nome;
            //Se vai rodar e parar no frame 0.
            public bool playAndStop;
            //Se vai rodar e 'sumir'
            public bool playAndDestroy;
            //Ativa? Se está ativa ou não, a animação
            public bool ativa;

        }

        animacao animacao_atual;


        public Object(Texture2D imagem, GameWindow Window, int animacao_width, int animacao_height, int qtd_quadros, int quadros_seg, bool playAndStop, bool playAndDestroy)
        {
            this.imagem = imagem;
            this.window = Window;
            this.visivel = true;
            this.alfa = 1;
            this.escala = 1f;

            this.isWalking = false;
            this.walkWay = new List<Vector2>();

            this.animacao_atual = new animacao();
            this.animacao_atual.imagem = imagem;
            this.animacao_atual.width = animacao_width;
            this.animacao_atual.height = animacao_height;
            this.animacao_atual.qtd_quadros = qtd_quadros;
            this.animacao_atual.quadros_seg = quadros_seg;
            this.animacao_atual.nome = "Default";
            this.animacao_atual.playAndStop = playAndStop;
            this.animacao_atual.playAndDestroy = playAndDestroy;
            this.animacao_atual.ativa = true;

            this.listaAnimacoes.Add(this.animacao_atual);

            listaGameObjects.Add(this);
        }


        public void Draw(GameTime gameTime, SpriteBatch spriteBatch)
        {
            if (visivel)
            {
                int frame;
                if (animacao_atual.ativa)
                {
                    frame = (int)(gameTime.TotalGameTime.TotalSeconds * animacao_atual.quadros_seg) % animacao_atual.qtd_quadros;
                }
                else
                {
                    frame = 0;
                }

                spriteBatch.Draw(
                    animacao_atual.imagem,
                    posicao,
                    new Rectangle(
                            frame * animacao_atual.width,
                             (animacao_atual.animacao_Y * animacao_atual.height),
                            animacao_atual.width,
                            animacao_atual.height),
                            new Color(1.0f * alfa, 1.0f * alfa, 1.0f * alfa, 1.0f * alfa),
                            rotacao,
                            pivo,
                            escala,
                            SpriteEffects.None,
                           // (direita) ? SpriteEffects.None : SpriteEffects.FlipHorizontally,
                            camada);

                if ((frame == animacao_atual.qtd_quadros-1) && animacao_atual.playAndStop)
                {
                   animacao_atual.ativa = false;
                   
                }

                if ((frame == animacao_atual.qtd_quadros - 1) && animacao_atual.playAndDestroy)
                {
                    this.visivel = false;

                }

           }

           
           
        }

        public void doMove(int dir)
        {
            switch (dir)
            {
                case 0: // Cima
                    {
                        this.posicao = new Vector2(this.posicao.X, this.posicao.Y - 32f);
                        break;
                    }
                case 1: // Direita
                    {
                        this.posicao = new Vector2(this.posicao.X + 32f, this.posicao.Y);
                        break;
                    }
                case 2: // Baixo
                    {
                        this.posicao = new Vector2(this.posicao.X, this.posicao.Y + 32f);
                        break;
                    }
                case 3: // Esquerda
                    {
                        this.posicao = new Vector2(this.posicao.X - 32f, this.posicao.Y);
                        break;
                    }
            }
        }

        public void doMove(int dir, float change)
        {
            Vector2 old_position = posicao;

            switch (dir)
            {
                case 0: // Cima
                case 2: // Baixo
                    {
                        this.posicao = new Vector2(this.posicao.X, this.posicao.Y + change);
                        break;
                    }
                case 1: // Direita
                case 3: // Esquerda
                    {
                        this.posicao = new Vector2(this.posicao.X + change, this.posicao.Y);
                        break;
                    }
            }

          
        }


        /// <summary>
        /// Adiciona uma nova animação.
        /// </summary>
        /// <param name="image">Texture 2D da imagem (Spritesheet).</param>
        /// <param name="animacao_width">Largura do frame.</param>
        /// <param name="animacao_height">Altura do frame.</param>
        /// <param name="qtd_quadros">Quantidade de quadros na animação.</param>
        /// <param name="quadros_seg">Quantidade de quadros exibidos por segundo.</param>
        /// <param name="nome">Nome da animação.</param>
        /// <param name="playAndStop">Se ela vai parar quando chegar na última frame.</param>
        /// <param name="ativa">Se está ativa.</param>
        public void addAnimation(Texture2D image, int animacao_width, int animacao_height, int qtd_quadros, int quadros_seg, string nome, bool playAndStop, bool ativa)
        {

            animacao _animation_ = new animacao();
            _animation_.imagem = image;
            _animation_.width = animacao_width;
            _animation_.height = animacao_height;
            _animation_.qtd_quadros = qtd_quadros;
            _animation_.quadros_seg = quadros_seg;
            _animation_.nome = nome;
            _animation_.playAndStop = playAndStop;
            _animation_.ativa = ativa;

            this.listaAnimacoes.Add(_animation_);

        }



        /// <summary>
        /// Muda a animação pra que for passada por parâmetro.
        /// </summary>
        /// <param name="animation_name">Nome da animação</param>
        public void changeAnimation(string animation_name)
        {
            foreach (animacao anim in listaAnimacoes)
            {
                if (anim.nome == animation_name)
                {
                    this.animacao_atual = anim;
                    this.animacao_atual.ativa = true;
                }
            }
        }

        

    }
}





